1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 package org.hibernate.ejb.criteria;
25
26 import java.io.Serializable;
27 import java.math.BigDecimal;
28 import java.math.BigInteger;
29 import java.util.Arrays;
30 import java.util.Collection;
31 import java.util.List;
32 import java.util.Map;
33 import java.util.Set;
34 import javax.persistence.Tuple;
35 import javax.persistence.criteria.CompoundSelection;
36 import javax.persistence.criteria.CriteriaBuilder;
37 import javax.persistence.criteria.CriteriaQuery;
38 import javax.persistence.criteria.Expression;
39 import javax.persistence.criteria.Order;
40 import javax.persistence.criteria.ParameterExpression;
41 import javax.persistence.criteria.Predicate;
42 import javax.persistence.criteria.Selection;
43 import javax.persistence.criteria.Subquery;
44
45 import org.hibernate.ejb.EntityManagerFactoryImpl;
46 import org.hibernate.ejb.criteria.expression.BinaryArithmeticOperation;
47 import org.hibernate.ejb.criteria.expression.CoalesceExpression;
48 import org.hibernate.ejb.criteria.expression.CompoundSelectionImpl;
49 import org.hibernate.ejb.criteria.expression.ConcatExpression;
50 import org.hibernate.ejb.criteria.expression.LiteralExpression;
51 import org.hibernate.ejb.criteria.expression.NullLiteralExpression;
52 import org.hibernate.ejb.criteria.expression.NullifExpression;
53 import org.hibernate.ejb.criteria.expression.ParameterExpressionImpl;
54 import org.hibernate.ejb.criteria.expression.SearchedCaseExpression;
55 import org.hibernate.ejb.criteria.expression.SimpleCaseExpression;
56 import org.hibernate.ejb.criteria.expression.SizeOfCollectionExpression;
57 import org.hibernate.ejb.criteria.expression.SubqueryComparisonModifierExpression;
58 import org.hibernate.ejb.criteria.expression.UnaryArithmeticOperation;
59 import org.hibernate.ejb.criteria.expression.function.AbsFunction;
60 import org.hibernate.ejb.criteria.expression.function.AggregationFunction;
61 import org.hibernate.ejb.criteria.expression.function.BasicFunctionExpression;
62 import org.hibernate.ejb.criteria.expression.function.CurrentDateFunction;
63 import org.hibernate.ejb.criteria.expression.function.CurrentTimeFunction;
64 import org.hibernate.ejb.criteria.expression.function.CurrentTimestampFunction;
65 import org.hibernate.ejb.criteria.expression.function.LengthFunction;
66 import org.hibernate.ejb.criteria.expression.function.LocateFunction;
67 import org.hibernate.ejb.criteria.expression.function.LowerFunction;
68 import org.hibernate.ejb.criteria.expression.function.ParameterizedFunctionExpression;
69 import org.hibernate.ejb.criteria.expression.function.SqrtFunction;
70 import org.hibernate.ejb.criteria.expression.function.SubstringFunction;
71 import org.hibernate.ejb.criteria.expression.function.TrimFunction;
72 import org.hibernate.ejb.criteria.expression.function.UpperFunction;
73 import org.hibernate.ejb.criteria.path.PluralAttributePath;
74 import org.hibernate.ejb.criteria.predicate.BetweenPredicate;
75 import org.hibernate.ejb.criteria.predicate.BooleanAssertionPredicate;
76 import org.hibernate.ejb.criteria.predicate.BooleanExpressionPredicate;
77 import org.hibernate.ejb.criteria.predicate.BooleanStaticAssertionPredicate;
78 import org.hibernate.ejb.criteria.predicate.ComparisonPredicate;
79 import org.hibernate.ejb.criteria.predicate.ComparisonPredicate.ComparisonOperator;
80 import org.hibernate.ejb.criteria.predicate.CompoundPredicate;
81 import org.hibernate.ejb.criteria.predicate.ExistsPredicate;
82 import org.hibernate.ejb.criteria.predicate.InPredicate;
83 import org.hibernate.ejb.criteria.predicate.IsEmptyPredicate;
84 import org.hibernate.ejb.criteria.predicate.LikePredicate;
85 import org.hibernate.ejb.criteria.predicate.MemberOfPredicate;
86 import org.hibernate.ejb.criteria.predicate.NullnessPredicate;
87
88
89
90
91
92
93 public class CriteriaBuilderImpl implements CriteriaBuilder, Serializable {
94 private final EntityManagerFactoryImpl entityManagerFactory;
95
96 public CriteriaBuilderImpl(EntityManagerFactoryImpl entityManagerFactory) {
97 this.entityManagerFactory = entityManagerFactory;
98 }
99
100
101
102
103
104
105 public EntityManagerFactoryImpl getEntityManagerFactory() {
106 return entityManagerFactory;
107 }
108
109
110
111
112 public CriteriaQuery<Object> createQuery() {
113 return new CriteriaQueryImpl<Object>( this, Object.class );
114 }
115
116
117
118
119 public <T> CriteriaQuery<T> createQuery(Class<T> resultClass) {
120 return new CriteriaQueryImpl<T>( this, resultClass );
121 }
122
123
124
125
126 public CriteriaQuery<Tuple> createTupleQuery() {
127 return new CriteriaQueryImpl<Tuple>( this, Tuple.class );
128 }
129
130
131
132
133
134
135
136
137
138
139
140
141
142 void checkMultiselect(List<Selection<?>> selections) {
143 for ( Selection<?> selection : selections ) {
144 if ( selection.isCompoundSelection() ) {
145 if ( selection.getJavaType().isArray() ) {
146 throw new IllegalArgumentException(
147 "multiselect selections cannot contain " +
148 "compound array-valued elements"
149 );
150 }
151 if ( Tuple.class.isAssignableFrom( selection.getJavaType() ) ) {
152 throw new IllegalArgumentException(
153 "multiselect selections cannot contain " +
154 "compound tuple-valued elements"
155 );
156 }
157 }
158 }
159 }
160
161
162
163
164 public CompoundSelection<Tuple> tuple(Selection<?>... selections) {
165 return tuple( Arrays.asList( selections ) );
166 }
167
168
169
170
171
172
173
174
175 public CompoundSelection<Tuple> tuple(List<Selection<?>> selections) {
176 checkMultiselect( selections );
177 return new CompoundSelectionImpl<Tuple>( this, Tuple.class, selections );
178 }
179
180
181
182
183 public CompoundSelection<Object[]> array(Selection<?>... selections) {
184 return array( Arrays.asList( selections ) );
185 }
186
187
188
189
190
191
192
193
194 public CompoundSelection<Object[]> array(List<Selection<?>> selections) {
195 return array( Object[].class, selections );
196 }
197
198
199
200
201
202
203
204
205
206
207 public <Y> CompoundSelection<Y> array(Class<Y> type, List<Selection<?>> selections) {
208 checkMultiselect( selections );
209 return new CompoundSelectionImpl<Y>( this, type, selections );
210 }
211
212
213
214
215 public <Y> CompoundSelection<Y> construct(Class<Y> result, Selection<?>... selections) {
216 return construct( result, Arrays.asList( selections ) );
217 }
218
219
220
221
222
223
224
225
226
227
228 public <Y> CompoundSelection<Y> construct(Class<Y> result, List<Selection<?>> selections) {
229 checkMultiselect( selections );
230 return new CompoundSelectionImpl<Y>( this, result, selections );
231 }
232
233
234
235
236
237
238
239 public Order asc(Expression<?> x) {
240 return new OrderImpl( x, true );
241 }
242
243
244
245
246 public Order desc(Expression<?> x) {
247 return new OrderImpl( x, false );
248 }
249
250
251
252
253 public Predicate wrap(Expression<Boolean> expression) {
254 if ( Predicate.class.isInstance( expression ) ) {
255 return ( (Predicate) expression );
256 }
257 else if ( PathImplementor.class.isInstance( expression ) ) {
258 return new BooleanAssertionPredicate( this, expression, Boolean.TRUE );
259 }
260 else {
261 return new BooleanExpressionPredicate( this, expression );
262 }
263 }
264
265
266
267
268 public Predicate not(Expression<Boolean> expression) {
269 return wrap( expression ).not();
270 }
271
272
273
274
275 public Predicate and(Expression<Boolean> x, Expression<Boolean> y) {
276 return new CompoundPredicate( this, Predicate.BooleanOperator.AND, x, y );
277 }
278
279
280
281
282 public Predicate or(Expression<Boolean> x, Expression<Boolean> y) {
283 return new CompoundPredicate( this, Predicate.BooleanOperator.OR, x, y );
284 }
285
286
287
288
289 public Predicate and(Predicate... restrictions) {
290 return new CompoundPredicate( this, Predicate.BooleanOperator.AND, restrictions );
291 }
292
293
294
295
296 public Predicate or(Predicate... restrictions) {
297 return new CompoundPredicate( this, Predicate.BooleanOperator.OR, restrictions );
298 }
299
300
301
302
303 public Predicate conjunction() {
304 return new CompoundPredicate( this, Predicate.BooleanOperator.AND );
305 }
306
307
308
309
310 public Predicate disjunction() {
311 return new CompoundPredicate( this, Predicate.BooleanOperator.OR );
312 }
313
314
315
316
317 public Predicate isTrue(Expression<Boolean> expression) {
318 if ( CompoundPredicate.class.isInstance( expression ) ) {
319 final CompoundPredicate predicate = (CompoundPredicate) expression;
320 if ( predicate.getExpressions().size() == 0 ) {
321 return new BooleanStaticAssertionPredicate(
322 this,
323 predicate.getOperator() == Predicate.BooleanOperator.AND
324 );
325 }
326 return predicate;
327 }
328 else if ( Predicate.class.isInstance( expression ) ) {
329 return (Predicate) expression;
330 }
331 return new BooleanAssertionPredicate( this, expression, Boolean.TRUE );
332 }
333
334
335
336
337 public Predicate isFalse(Expression<Boolean> expression) {
338 if ( CompoundPredicate.class.isInstance( expression ) ) {
339 final CompoundPredicate predicate = (CompoundPredicate) expression;
340 if ( predicate.getExpressions().size() == 0 ) {
341 return new BooleanStaticAssertionPredicate(
342 this,
343 predicate.getOperator() == Predicate.BooleanOperator.OR
344 );
345 }
346 predicate.not();
347 return predicate;
348 }
349 else if ( Predicate.class.isInstance( expression ) ) {
350 final Predicate predicate = (Predicate) expression;
351 predicate.not();
352 return predicate;
353 }
354 return new BooleanAssertionPredicate( this, expression, Boolean.FALSE );
355 }
356
357
358
359
360 public Predicate isNull(Expression<?> x) {
361 return new NullnessPredicate( this, x );
362 }
363
364
365
366
367 public Predicate isNotNull(Expression<?> x) {
368 return isNull( x ).not();
369 }
370
371
372
373
374 public Predicate equal(Expression<?> x, Expression<?> y) {
375
376 return new ComparisonPredicate( this, ComparisonOperator.EQUAL, x, y );
377 }
378
379
380
381
382 public Predicate notEqual(Expression<?> x, Expression<?> y) {
383
384 return new ComparisonPredicate( this, ComparisonOperator.NOT_EQUAL, x, y );
385 }
386
387
388
389
390 public Predicate equal(Expression<?> x, Object y) {
391
392 return new ComparisonPredicate( this, ComparisonOperator.EQUAL, x, y );
393 }
394
395
396
397
398 public Predicate notEqual(Expression<?> x, Object y) {
399
400 return new ComparisonPredicate( this, ComparisonOperator.NOT_EQUAL, x, y );
401 }
402
403
404
405
406 public <Y extends Comparable<? super Y>> Predicate greaterThan(Expression<? extends Y> x, Expression<? extends Y> y) {
407
408 return new ComparisonPredicate( this, ComparisonOperator.GREATER_THAN, x, y );
409 }
410
411
412
413
414 public <Y extends Comparable<? super Y>> Predicate lessThan(
415 Expression<? extends Y> x,
416 Expression<? extends Y> y) {
417
418 return new ComparisonPredicate( this, ComparisonOperator.LESS_THAN, x, y );
419 }
420
421
422
423
424 public <Y extends Comparable<? super Y>> Predicate greaterThanOrEqualTo(
425 Expression<? extends Y> x,
426 Expression<? extends Y> y) {
427
428 return new ComparisonPredicate( this, ComparisonOperator.GREATER_THAN_OR_EQUAL, x, y );
429 }
430
431
432
433
434 public <Y extends Comparable<? super Y>> Predicate lessThanOrEqualTo(
435 Expression<? extends Y> x,
436 Expression<? extends Y> y) {
437
438 return new ComparisonPredicate( this, ComparisonOperator.LESS_THAN_OR_EQUAL, x, y );
439 }
440
441
442
443
444 public <Y extends Comparable<? super Y>> Predicate greaterThan(
445 Expression<? extends Y> x,
446 Y y) {
447
448 return new ComparisonPredicate( this, ComparisonOperator.GREATER_THAN, x, y );
449 }
450
451
452
453
454 public <Y extends Comparable<? super Y>> Predicate lessThan(
455 Expression<? extends Y> x,
456 Y y) {
457
458 return new ComparisonPredicate( this, ComparisonOperator.LESS_THAN, x, y );
459 }
460
461
462
463
464 public <Y extends Comparable<? super Y>> Predicate greaterThanOrEqualTo(
465 Expression<? extends Y> x,
466 Y y) {
467
468 return new ComparisonPredicate( this, ComparisonOperator.GREATER_THAN_OR_EQUAL, x, y );
469 }
470
471
472
473
474 public<Y extends Comparable<? super Y>> Predicate lessThanOrEqualTo(
475 Expression<? extends Y> x,
476 Y y) {
477
478 return new ComparisonPredicate( this, ComparisonOperator.LESS_THAN_OR_EQUAL, x, y );
479 }
480
481
482
483
484 public Predicate gt(Expression<? extends Number> x, Expression<? extends Number> y) {
485
486 return new ComparisonPredicate( this, ComparisonOperator.GREATER_THAN, x, y );
487 }
488
489
490
491
492 public Predicate lt(Expression<? extends Number> x, Expression<? extends Number> y) {
493
494 return new ComparisonPredicate( this, ComparisonOperator.LESS_THAN, x, y );
495 }
496
497
498
499
500 public Predicate ge(Expression<? extends Number> x, Expression<? extends Number> y) {
501
502 return new ComparisonPredicate( this, ComparisonOperator.GREATER_THAN_OR_EQUAL, x, y );
503 }
504
505
506
507
508 public Predicate le(Expression<? extends Number> x, Expression<? extends Number> y) {
509
510 return new ComparisonPredicate( this, ComparisonOperator.LESS_THAN_OR_EQUAL, x, y );
511 }
512
513
514
515
516 public Predicate gt(Expression<? extends Number> x, Number y) {
517
518 return new ComparisonPredicate( this, ComparisonOperator.GREATER_THAN, x, y );
519 }
520
521
522
523
524 public Predicate lt(Expression<? extends Number> x, Number y) {
525
526 return new ComparisonPredicate( this, ComparisonOperator.LESS_THAN, x, y );
527 }
528
529
530
531
532 public Predicate ge(Expression<? extends Number> x, Number y) {
533
534 return new ComparisonPredicate( this, ComparisonOperator.GREATER_THAN_OR_EQUAL, x, y );
535 }
536
537
538
539
540 public Predicate le(Expression<? extends Number> x, Number y) {
541
542 return new ComparisonPredicate( this, ComparisonOperator.LESS_THAN_OR_EQUAL, x, y );
543 }
544
545
546
547
548 public <Y extends Comparable<? super Y>> Predicate between(
549 Expression<? extends Y> expression,
550 Y lowerBound,
551 Y upperBound) {
552 return new BetweenPredicate<Y>( this, expression, lowerBound, upperBound );
553 }
554
555
556
557
558 public <Y extends Comparable<? super Y>> Predicate between(
559 Expression<? extends Y> expression,
560 Expression<? extends Y> lowerBound,
561 Expression<? extends Y> upperBound) {
562 return new BetweenPredicate<Y>( this, expression, lowerBound, upperBound );
563 }
564
565
566
567
568 public <T> In<T> in(Expression<? extends T> expression) {
569 return new InPredicate<T>( this, expression );
570 }
571
572 public <T> In<T> in(Expression<? extends T> expression, Expression<? extends T>... values) {
573 return new InPredicate<T>( this, expression, values );
574 }
575
576 public <T> In<T> in(Expression<? extends T> expression, T... values) {
577 return new InPredicate<T>( this, expression, values );
578 }
579
580 public <T> In<T> in(Expression<? extends T> expression, Collection<T> values) {
581 return new InPredicate<T>( this, expression, values );
582 }
583
584 public Predicate like(Expression<String> matchExpression, Expression<String> pattern) {
585 return new LikePredicate( this, matchExpression, pattern );
586 }
587
588 public Predicate like(Expression<String> matchExpression, Expression<String> pattern, Expression<Character> escapeCharacter) {
589 return new LikePredicate( this, matchExpression, pattern, escapeCharacter );
590 }
591
592 public Predicate like(Expression<String> matchExpression, Expression<String> pattern, char escapeCharacter) {
593 return new LikePredicate( this, matchExpression, pattern, escapeCharacter );
594 }
595
596 public Predicate like(Expression<String> matchExpression, String pattern) {
597 return new LikePredicate( this, matchExpression, pattern );
598 }
599
600 public Predicate like(Expression<String> matchExpression, String pattern, Expression<Character> escapeCharacter) {
601 return new LikePredicate( this, matchExpression, pattern, escapeCharacter );
602 }
603
604 public Predicate like(Expression<String> matchExpression, String pattern, char escapeCharacter) {
605 return new LikePredicate( this, matchExpression, pattern, escapeCharacter );
606 }
607
608 public Predicate notLike(Expression<String> matchExpression, Expression<String> pattern) {
609 return like( matchExpression, pattern ).not();
610 }
611
612 public Predicate notLike(Expression<String> matchExpression, Expression<String> pattern, Expression<Character> escapeCharacter) {
613 return like( matchExpression, pattern, escapeCharacter ).not();
614 }
615
616 public Predicate notLike(Expression<String> matchExpression, Expression<String> pattern, char escapeCharacter) {
617 return like( matchExpression, pattern, escapeCharacter ).not();
618 }
619
620 public Predicate notLike(Expression<String> matchExpression, String pattern) {
621 return like( matchExpression, pattern ).not();
622 }
623
624 public Predicate notLike(Expression<String> matchExpression, String pattern, Expression<Character> escapeCharacter) {
625 return like( matchExpression, pattern, escapeCharacter ).not();
626 }
627
628 public Predicate notLike(Expression<String> matchExpression, String pattern, char escapeCharacter) {
629 return like( matchExpression, pattern, escapeCharacter ).not();
630 }
631
632
633
634
635
636
637
638 public <T> ParameterExpression<T> parameter(Class<T> paramClass) {
639 return new ParameterExpressionImpl<T>( this, paramClass );
640 }
641
642
643
644
645 public <T> ParameterExpression<T> parameter(Class<T> paramClass, String name) {
646 return new ParameterExpressionImpl<T>( this, paramClass, name );
647 }
648
649
650
651
652 public <T> Expression<T> literal(T value) {
653 if ( value == null ) {
654 throw new IllegalArgumentException( "literal value cannot be null" );
655 }
656 return new LiteralExpression<T>( this, value );
657 }
658
659
660
661
662 public <T> Expression<T> nullLiteral(Class<T> resultClass) {
663 return new NullLiteralExpression<T>( this, resultClass );
664 }
665
666
667
668
669
670
671
672 public <N extends Number> Expression<Double> avg(Expression<N> x) {
673 return new AggregationFunction.AVG( this, x );
674 }
675
676
677
678
679 public <N extends Number> Expression<N> sum(Expression<N> x) {
680 return new AggregationFunction.SUM<N>( this, x );
681 }
682
683
684
685
686 public Expression<Long> sumAsLong(Expression<Integer> x) {
687 return new AggregationFunction.SUM<Long>( this, x, Long.class );
688 }
689
690
691
692
693 public Expression<Double> sumAsDouble(Expression<Float> x) {
694 return new AggregationFunction.SUM<Double>( this, x, Double.class );
695 }
696
697
698
699
700 public <N extends Number> Expression<N> max(Expression<N> x) {
701 return new AggregationFunction.MAX<N>( this, x );
702 }
703
704
705
706
707 public <N extends Number> Expression<N> min(Expression<N> x) {
708 return new AggregationFunction.MIN<N>( this, x );
709 }
710
711
712
713
714 @SuppressWarnings({ "unchecked" })
715 public <X extends Comparable<? super X>> Expression<X> greatest(Expression<X> x) {
716 return new AggregationFunction.GREATEST( this, x );
717 }
718
719
720
721
722 @SuppressWarnings({ "unchecked" })
723 public <X extends Comparable<? super X>> Expression<X> least(Expression<X> x) {
724 return new AggregationFunction.LEAST( this, x );
725 }
726
727
728
729
730 public Expression<Long> count(Expression<?> x) {
731 return new AggregationFunction.COUNT( this, x, false );
732 }
733
734
735
736
737 public Expression<Long> countDistinct(Expression<?> x) {
738 return new AggregationFunction.COUNT( this, x, true );
739 }
740
741
742
743
744
745
746
747 public <T> Expression<T> function(String name, Class<T> returnType, Expression<?>... arguments) {
748 return new ParameterizedFunctionExpression<T>( this, returnType, name, arguments );
749 }
750
751
752
753
754
755
756
757
758
759 public <T> Expression<T> function(String name, Class<T> returnType) {
760 return new BasicFunctionExpression<T>( this, returnType, name );
761 }
762
763
764
765
766 public <N extends Number> Expression<N> abs(Expression<N> expression) {
767 return new AbsFunction<N>( this, expression );
768 }
769
770
771
772
773 public Expression<Double> sqrt(Expression<? extends Number> expression) {
774 return new SqrtFunction( this, expression );
775 }
776
777 public Expression<java.sql.Date> currentDate() {
778 return new CurrentDateFunction( this );
779 }
780
781 public Expression<java.sql.Timestamp> currentTimestamp() {
782 return new CurrentTimestampFunction( this );
783 }
784
785 public Expression<java.sql.Time> currentTime() {
786 return new CurrentTimeFunction( this );
787 }
788
789 public Expression<String> substring(Expression<String> value, Expression<Integer> start) {
790 return new SubstringFunction( this, value, start );
791 }
792
793 public Expression<String> substring(Expression<String> value, int start) {
794 return new SubstringFunction( this, value, start );
795 }
796
797 public Expression<String> substring(Expression<String> value, Expression<Integer> start, Expression<Integer> length) {
798 return new SubstringFunction( this, value, start, length );
799 }
800
801 public Expression<String> substring(Expression<String> value, int start, int length) {
802 return new SubstringFunction( this, value, start, length );
803 }
804
805 public Expression<String> trim(Expression<String> trimSource ) {
806 return new TrimFunction( this, trimSource );
807 }
808
809 public Expression<String> trim(Trimspec trimspec, Expression<String> trimSource) {
810 return new TrimFunction( this, trimspec, trimSource );
811 }
812
813 public Expression<String> trim(Expression<Character> trimCharacter, Expression<String> trimSource) {
814 return new TrimFunction( this, trimCharacter, trimSource );
815 }
816
817 public Expression<String> trim(Trimspec trimspec, Expression<Character> trimCharacter, Expression<String> trimSource) {
818 return new TrimFunction( this, trimspec, trimCharacter, trimSource );
819 }
820
821 public Expression<String> trim(char trimCharacter, Expression<String> trimSource) {
822 return new TrimFunction( this, trimCharacter, trimSource );
823 }
824
825 public Expression<String> trim(Trimspec trimspec, char trimCharacter, Expression<String> trimSource) {
826 return new TrimFunction( this, trimspec, trimCharacter, trimSource );
827 }
828
829 public Expression<String> lower(Expression<String> value) {
830 return new LowerFunction( this, value );
831 }
832
833 public Expression<String> upper(Expression<String> value) {
834 return new UpperFunction( this, value );
835 }
836
837 public Expression<Integer> length(Expression<String> value) {
838 return new LengthFunction( this, value );
839 }
840
841 public Expression<Integer> locate(Expression<String> string, Expression<String> pattern) {
842 return new LocateFunction( this, pattern, string );
843 }
844
845 public Expression<Integer> locate(Expression<String> string, Expression<String> pattern, Expression<Integer> start) {
846 return new LocateFunction( this, pattern, string, start );
847 }
848
849 public Expression<Integer> locate(Expression<String> string, String pattern) {
850 return new LocateFunction( this, pattern, string );
851 }
852
853 public Expression<Integer> locate(Expression<String> string, String pattern, int start) {
854 return new LocateFunction( this, pattern, string, start );
855 }
856
857
858
859
860 @Override
861 public <N extends Number> Expression<N> neg(Expression<N> expression) {
862 return new UnaryArithmeticOperation<N>(
863 this,
864 UnaryArithmeticOperation.Operation.UNARY_MINUS,
865 expression
866 );
867 }
868
869 @Override
870 @SuppressWarnings({ "unchecked" })
871 public <N extends Number> Expression<N> sum(Expression<? extends N> expression1, Expression<? extends N> expression2) {
872 if ( expression1 == null || expression2 == null ) {
873 throw new IllegalArgumentException( "arguments to sum() cannot be null" );
874 }
875
876 final Class resultType = BinaryArithmeticOperation.determineResultType( expression1.getJavaType(), expression2.getJavaType() );
877
878 return new BinaryArithmeticOperation<N>(
879 this,
880 resultType,
881 BinaryArithmeticOperation.Operation.ADD,
882 expression1,
883 expression2
884 );
885 }
886
887 @Override
888 @SuppressWarnings({ "unchecked" })
889 public <N extends Number> Expression<N> prod(Expression<? extends N> expression1, Expression<? extends N> expression2) {
890 if ( expression1 == null || expression2 == null ) {
891 throw new IllegalArgumentException( "arguments to prod() cannot be null" );
892 }
893
894 final Class resultType = BinaryArithmeticOperation.determineResultType( expression1.getJavaType(), expression2.getJavaType() );
895
896 return new BinaryArithmeticOperation<N>(
897 this,
898 resultType,
899 BinaryArithmeticOperation.Operation.MULTIPLY,
900 expression1,
901 expression2
902 );
903 }
904
905 @Override
906 @SuppressWarnings({ "unchecked" })
907 public <N extends Number> Expression<N> diff(Expression<? extends N> expression1, Expression<? extends N> expression2) {
908 if ( expression1 == null || expression2 == null ) {
909 throw new IllegalArgumentException( "arguments to diff() cannot be null" );
910 }
911
912 final Class resultType = BinaryArithmeticOperation.determineResultType( expression1.getJavaType(), expression2.getJavaType() );
913
914 return new BinaryArithmeticOperation<N>(
915 this,
916 resultType,
917 BinaryArithmeticOperation.Operation.SUBTRACT,
918 expression1,
919 expression2
920 );
921 }
922
923 @Override
924 @SuppressWarnings({ "unchecked" })
925 public <N extends Number> Expression<N> sum(Expression<? extends N> expression, N n) {
926 if ( expression == null || n == null ) {
927 throw new IllegalArgumentException( "arguments to sum() cannot be null" );
928 }
929
930 final Class resultType = BinaryArithmeticOperation.determineResultType( expression.getJavaType(), n.getClass() );
931
932 return new BinaryArithmeticOperation<N>(
933 this,
934 resultType,
935 BinaryArithmeticOperation.Operation.ADD,
936 expression,
937 n
938 );
939 }
940
941 @Override
942 @SuppressWarnings({ "unchecked" })
943 public <N extends Number> Expression<N> prod(Expression<? extends N> expression, N n) {
944 if ( expression == null || n == null ) {
945 throw new IllegalArgumentException( "arguments to prod() cannot be null" );
946 }
947
948 final Class resultType = BinaryArithmeticOperation.determineResultType( expression.getJavaType(), n.getClass() );
949
950 return new BinaryArithmeticOperation<N>(
951 this,
952 resultType,
953 BinaryArithmeticOperation.Operation.MULTIPLY,
954 expression,
955 n
956 );
957 }
958
959 @Override
960 @SuppressWarnings({ "unchecked" })
961 public <N extends Number> Expression<N> diff(Expression<? extends N> expression, N n) {
962 if ( expression == null || n == null ) {
963 throw new IllegalArgumentException( "arguments to diff() cannot be null" );
964 }
965
966 final Class resultType = BinaryArithmeticOperation.determineResultType( expression.getJavaType(), n.getClass() );
967
968 return new BinaryArithmeticOperation<N>(
969 this,
970 resultType,
971 BinaryArithmeticOperation.Operation.SUBTRACT,
972 expression,
973 n
974 );
975 }
976
977 @Override
978 @SuppressWarnings({ "unchecked" })
979 public <N extends Number> Expression<N> sum(N n, Expression<? extends N> expression) {
980 if ( expression == null || n == null ) {
981 throw new IllegalArgumentException( "arguments to sum() cannot be null" );
982 }
983
984 final Class resultType = BinaryArithmeticOperation.determineResultType( n.getClass(), expression.getJavaType() );
985
986 return new BinaryArithmeticOperation<N>(
987 this,
988 resultType,
989 BinaryArithmeticOperation.Operation.ADD,
990 n,
991 expression
992 );
993 }
994
995 @Override
996 @SuppressWarnings({ "unchecked" })
997 public <N extends Number> Expression<N> prod(N n, Expression<? extends N> expression) {
998 if ( n == null || expression == null ) {
999 throw new IllegalArgumentException( "arguments to prod() cannot be null" );
1000 }
1001
1002 final Class resultType = BinaryArithmeticOperation.determineResultType( n.getClass(), expression.getJavaType() );
1003
1004 return (BinaryArithmeticOperation<N>) new BinaryArithmeticOperation(
1005 this,
1006 resultType,
1007 BinaryArithmeticOperation.Operation.MULTIPLY,
1008 n,
1009 expression
1010 );
1011 }
1012
1013 @Override
1014 @SuppressWarnings({ "unchecked" })
1015 public <N extends Number> Expression<N> diff(N n, Expression<? extends N> expression) {
1016 if ( n == null || expression == null ) {
1017 throw new IllegalArgumentException( "arguments to diff() cannot be null" );
1018 }
1019
1020 final Class resultType = BinaryArithmeticOperation.determineResultType( n.getClass(), expression.getJavaType() );
1021
1022 return new BinaryArithmeticOperation<N>(
1023 this,
1024 resultType,
1025 BinaryArithmeticOperation.Operation.SUBTRACT,
1026 n,
1027 expression
1028 );
1029 }
1030
1031 @Override
1032 @SuppressWarnings( {"unchecked"})
1033 public Expression<Number> quot(Expression<? extends Number> expression1, Expression<? extends Number> expression2) {
1034 if ( expression1 == null || expression2 == null ) {
1035 throw new IllegalArgumentException( "arguments to quot() cannot be null" );
1036 }
1037
1038 final Class resultType = BinaryArithmeticOperation.determineResultType( expression1.getJavaType(), expression2.getJavaType(), true );
1039
1040 return new BinaryArithmeticOperation<Number>(
1041 this,
1042 resultType,
1043 BinaryArithmeticOperation.Operation.DIVIDE,
1044 expression1,
1045 expression2
1046 );
1047 }
1048
1049 @Override
1050 @SuppressWarnings( {"unchecked"})
1051 public Expression<Number> quot(Expression<? extends Number> expression, Number number) {
1052 if ( expression == null || number == null ) {
1053 throw new IllegalArgumentException( "arguments to quot() cannot be null" );
1054 }
1055
1056 final Class resultType = BinaryArithmeticOperation.determineResultType( expression.getJavaType(), number.getClass(), true );
1057
1058 return new BinaryArithmeticOperation<Number>(
1059 this,
1060 resultType,
1061 BinaryArithmeticOperation.Operation.DIVIDE,
1062 expression,
1063 number
1064 );
1065 }
1066
1067 @Override
1068 @SuppressWarnings( {"unchecked"})
1069 public Expression<Number> quot(Number number, Expression<? extends Number> expression) {
1070 if ( expression == null || number == null ) {
1071 throw new IllegalArgumentException( "arguments to quot() cannot be null" );
1072 }
1073
1074 final Class resultType = BinaryArithmeticOperation.determineResultType( number.getClass(), expression.getJavaType(), true );
1075
1076 return new BinaryArithmeticOperation<Number>(
1077 this,
1078 resultType,
1079 BinaryArithmeticOperation.Operation.DIVIDE,
1080 number,
1081 expression
1082 );
1083 }
1084
1085 @Override
1086 public Expression<Integer> mod(Expression<Integer> expression1, Expression<Integer> expression2) {
1087 if ( expression1 == null || expression2 == null ) {
1088 throw new IllegalArgumentException( "arguments to mod() cannot be null" );
1089 }
1090
1091 return new BinaryArithmeticOperation<Integer>(
1092 this,
1093 Integer.class,
1094 BinaryArithmeticOperation.Operation.MOD,
1095 expression1,
1096 expression2
1097 );
1098 }
1099
1100 @Override
1101 public Expression<Integer> mod(Expression<Integer> expression, Integer integer) {
1102 if ( expression == null || integer == null ) {
1103 throw new IllegalArgumentException( "arguments to mod() cannot be null" );
1104 }
1105
1106 return new BinaryArithmeticOperation<Integer>(
1107 this,
1108 Integer.class,
1109 BinaryArithmeticOperation.Operation.MOD,
1110 expression,
1111 integer
1112 );
1113 }
1114
1115 @Override
1116 public Expression<Integer> mod(Integer integer, Expression<Integer> expression) {
1117 if ( integer == null || expression == null ) {
1118 throw new IllegalArgumentException( "arguments to mod() cannot be null" );
1119 }
1120
1121 return new BinaryArithmeticOperation<Integer>(
1122 this,
1123 Integer.class,
1124 BinaryArithmeticOperation.Operation.MOD,
1125 integer,
1126 expression
1127 );
1128 }
1129
1130
1131
1132
1133
1134
1135
1136 public ExpressionImplementor<Long> toLong(Expression<? extends Number> expression) {
1137 return ( (ExpressionImplementor<? extends Number>) expression ).asLong();
1138 }
1139
1140
1141
1142
1143 public ExpressionImplementor<Integer> toInteger(Expression<? extends Number> expression) {
1144 return ( (ExpressionImplementor<? extends Number>) expression ).asInteger();
1145 }
1146
1147
1148
1149
1150 public ExpressionImplementor<Float> toFloat(Expression<? extends Number> expression) {
1151 return ( (ExpressionImplementor<? extends Number>) expression ).asFloat();
1152 }
1153
1154
1155
1156
1157 public ExpressionImplementor<Double> toDouble(Expression<? extends Number> expression) {
1158 return ( (ExpressionImplementor<? extends Number>) expression ).asDouble();
1159 }
1160
1161
1162
1163
1164 public ExpressionImplementor<BigDecimal> toBigDecimal(Expression<? extends Number> expression) {
1165 return ( (ExpressionImplementor<? extends Number>) expression ).asBigDecimal();
1166 }
1167
1168
1169
1170
1171 public ExpressionImplementor<BigInteger> toBigInteger(Expression<? extends Number> expression) {
1172 return ( (ExpressionImplementor<? extends Number>) expression ).asBigInteger();
1173 }
1174
1175
1176
1177
1178 public ExpressionImplementor<String> toString(Expression<Character> characterExpression) {
1179 return ( (ExpressionImplementor<Character>) characterExpression ).asString();
1180 }
1181
1182
1183
1184
1185
1186
1187
1188 public Predicate exists(Subquery<?> subquery) {
1189 return new ExistsPredicate( this, subquery );
1190 }
1191
1192
1193
1194
1195 @SuppressWarnings({ "unchecked" })
1196 public <Y> Expression<Y> all(Subquery<Y> subquery) {
1197 return new SubqueryComparisonModifierExpression<Y>(
1198 this,
1199 (Class<Y>) subquery.getJavaType(),
1200 subquery,
1201 SubqueryComparisonModifierExpression.Modifier.ALL
1202 );
1203 }
1204
1205
1206
1207
1208 @SuppressWarnings({ "unchecked" })
1209 public <Y> Expression<Y> some(Subquery<Y> subquery) {
1210 return new SubqueryComparisonModifierExpression<Y>(
1211 this,
1212 (Class<Y>) subquery.getJavaType(),
1213 subquery,
1214 SubqueryComparisonModifierExpression.Modifier.SOME
1215 );
1216 }
1217
1218
1219
1220
1221 @SuppressWarnings({ "unchecked" })
1222 public <Y> Expression<Y> any(Subquery<Y> subquery) {
1223 return new SubqueryComparisonModifierExpression<Y>(
1224 this,
1225 (Class<Y>) subquery.getJavaType(),
1226 subquery,
1227 SubqueryComparisonModifierExpression.Modifier.ANY
1228 );
1229 }
1230
1231
1232
1233
1234
1235
1236
1237 @SuppressWarnings({ "RedundantCast" })
1238 public <Y> Expression<Y> coalesce(Expression<? extends Y> exp1, Expression<? extends Y> exp2) {
1239 return coalesce( (Class<Y>) null, exp1, exp2 );
1240 }
1241
1242 public <Y> Expression<Y> coalesce(Class<Y> type, Expression<? extends Y> exp1, Expression<? extends Y> exp2) {
1243 return new CoalesceExpression<Y>( this, type ).value( exp1 ).value( exp2 );
1244 }
1245
1246
1247
1248
1249 @SuppressWarnings({ "RedundantCast" })
1250 public <Y> Expression<Y> coalesce(Expression<? extends Y> exp1, Y exp2) {
1251 return coalesce( (Class<Y>) null, exp1, exp2 );
1252 }
1253
1254 public <Y> Expression<Y> coalesce(Class<Y> type, Expression<? extends Y> exp1, Y exp2) {
1255 return new CoalesceExpression<Y>( this, type ).value( exp1 ).value( exp2 );
1256 }
1257
1258
1259
1260
1261 public <T> Coalesce<T> coalesce() {
1262 return coalesce( (Class<T>)null );
1263 }
1264
1265 public <T> Coalesce<T> coalesce(Class<T> type) {
1266 return new CoalesceExpression<T>( this, type );
1267 }
1268
1269
1270
1271
1272 public Expression<String> concat(Expression<String> string1, Expression<String> string2) {
1273 return new ConcatExpression( this, string1, string2 );
1274 }
1275
1276
1277
1278
1279 public Expression<String> concat(Expression<String> string1, String string2) {
1280 return new ConcatExpression( this, string1, string2 );
1281 }
1282
1283
1284
1285
1286 public Expression<String> concat(String string1, Expression<String> string2) {
1287 return new ConcatExpression( this, string1, string2 );
1288 }
1289
1290
1291
1292
1293 public <Y> Expression<Y> nullif(Expression<Y> exp1, Expression<?> exp2) {
1294 return nullif( null, exp1, exp2 );
1295 }
1296
1297 public <Y> Expression<Y> nullif(Class<Y> type, Expression<Y> exp1, Expression<?> exp2) {
1298 return new NullifExpression<Y>( this, type, exp1, exp2 );
1299 }
1300
1301
1302
1303
1304 public <Y> Expression<Y> nullif(Expression<Y> exp1, Y exp2) {
1305 return nullif( null, exp1, exp2 );
1306 }
1307
1308 public <Y> Expression<Y> nullif(Class<Y> type, Expression<Y> exp1, Y exp2) {
1309 return new NullifExpression<Y>( this, type, exp1, exp2 );
1310 }
1311
1312
1313
1314
1315 public <C, R> SimpleCase<C, R> selectCase(Expression<? extends C> expression) {
1316 return selectCase( (Class<R>)null, expression );
1317 }
1318
1319 public <C, R> SimpleCase<C, R> selectCase(Class<R> type, Expression<? extends C> expression) {
1320 return new SimpleCaseExpression<C, R>( this, type, expression );
1321 }
1322
1323
1324
1325
1326 public <R> Case<R> selectCase() {
1327 return selectCase( (Class<R>)null );
1328 }
1329
1330 public <R> Case<R> selectCase(Class<R> type) {
1331 return new SearchedCaseExpression<R>( this, type );
1332 }
1333
1334
1335
1336
1337 public <C extends Collection<?>> Expression<Integer> size(C c) {
1338 int size = c == null ? 0 : c.size();
1339 return new LiteralExpression<Integer>(this, Integer.class, size);
1340 }
1341
1342
1343
1344
1345 public <C extends Collection<?>> Expression<Integer> size(Expression<C> exp) {
1346 if ( LiteralExpression.class.isInstance(exp) ) {
1347 return size( ( (LiteralExpression<C>) exp ).getLiteral() );
1348 }
1349 else if ( PluralAttributePath.class.isInstance(exp) ) {
1350 return new SizeOfCollectionExpression<C>(this, (PluralAttributePath<C>) exp );
1351 }
1352
1353 throw new IllegalArgumentException("unknown collection expression type [" + exp.getClass().getName() + "]" );
1354 }
1355
1356
1357
1358
1359 public <V, M extends Map<?, V>> Expression<Collection<V>> values(M map) {
1360 return new LiteralExpression<Collection<V>>( this, map.values() );
1361 }
1362
1363
1364
1365
1366 public <K, M extends Map<K, ?>> Expression<Set<K>> keys(M map) {
1367 return new LiteralExpression<Set<K>>( this, map.keySet() );
1368 }
1369
1370
1371
1372
1373
1374 @SuppressWarnings({ "unchecked" })
1375 public <C extends Collection<?>> Predicate isEmpty(Expression<C> collectionExpression) {
1376 if ( PluralAttributePath.class.isInstance(collectionExpression) ) {
1377 return new IsEmptyPredicate( this, (PluralAttributePath<C>) collectionExpression );
1378 }
1379
1380 throw new IllegalArgumentException(
1381 "unknown collection expression type [" + collectionExpression.getClass().getName() + "]"
1382 );
1383 }
1384
1385
1386
1387
1388 public <C extends Collection<?>> Predicate isNotEmpty(Expression<C> collectionExpression) {
1389 return isEmpty( collectionExpression ).not();
1390 }
1391
1392
1393
1394
1395 public <E, C extends Collection<E>> Predicate isMember(E e, Expression<C> collectionExpression) {
1396 if ( ! PluralAttributePath.class.isInstance( collectionExpression ) ) {
1397 throw new IllegalArgumentException(
1398 "unknown collection expression type [" + collectionExpression.getClass().getName() + "]"
1399 );
1400 }
1401 return new MemberOfPredicate<E, C>(
1402 this,
1403 e,
1404 (PluralAttributePath<C>)collectionExpression
1405 );
1406 }
1407
1408
1409
1410
1411 public <E, C extends Collection<E>> Predicate isNotMember(E e, Expression<C> cExpression) {
1412 return isMember(e, cExpression).not();
1413 }
1414
1415
1416
1417
1418 public <E, C extends Collection<E>> Predicate isMember(Expression<E> elementExpression, Expression<C> collectionExpression) {
1419 if ( ! PluralAttributePath.class.isInstance( collectionExpression ) ) {
1420 throw new IllegalArgumentException(
1421 "unknown collection expression type [" + collectionExpression.getClass().getName() + "]"
1422 );
1423 }
1424 return new MemberOfPredicate<E, C>(
1425 this,
1426 elementExpression,
1427 (PluralAttributePath<C>)collectionExpression
1428 );
1429 }
1430
1431
1432
1433
1434 public <E, C extends Collection<E>> Predicate isNotMember(Expression<E> eExpression, Expression<C> cExpression) {
1435 return isMember(eExpression, cExpression).not();
1436 }
1437 }